﻿using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using HslCommunication.BasicFramework;
using HslCommunication.Reflection;

namespace HslCommunication.Core.Net
{
	/// <summary>
	/// 设备交互类的基类，实现了<see cref="T:HslCommunication.Core.IReadWriteNet" />接口的基础方法方法，需要使用继承重写来实现字节读写，bool读写操作。<br />
	/// The base class of the device interaction class, which implements the basic methods of the <see cref="T:HslCommunication.Core.IReadWriteNet" /> interface, 
	/// requires inheritance rewriting to implement byte read and write, and bool read and write operations.
	/// </summary>
	/// <remarks>需要继承实现采用使用。</remarks>
	// Token: 0x02000139 RID: 313
	public class NetworkDeviceBase : NetworkDoubleBase, IReadWriteNet
	{
		/// <summary>
		/// 一个字单位的数据表示的地址长度，西门子为2，三菱，欧姆龙，modbusTcp就为1，AB PLC无效<br />
		/// The address length represented by one word of data, Siemens is 2, Mitsubishi, Omron, modbusTcp is 1, AB PLC is invalid
		/// </summary>
		/// <remarks>
		/// 对设备来说，一个地址的数据对应的字节数，或是1个字节或是2个字节，通常是这两个选择
		/// </remarks>
		// Token: 0x1700056A RID: 1386
		// (get) Token: 0x06001AC9 RID: 6857 RVA: 0x0008608D File Offset: 0x0008428D
		// (set) Token: 0x06001ACA RID: 6858 RVA: 0x00086095 File Offset: 0x00084295
		protected ushort WordLength { get; set; } = 1;

		/// <inheritdoc />
		// Token: 0x06001ACB RID: 6859 RVA: 0x000860A0 File Offset: 0x000842A0
		public override string ToString()
		{
			return string.Format("NetworkDeviceBase<{0}, {1}>[{2}:{3}]", new object[]
			{
				this.GetNewNetMessage().GetType(),
				base.ByteTransform.GetType(),
				this.IpAddress,
				this.Port
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Read(System.String,System.UInt16)" />
		// Token: 0x06001ACC RID: 6860 RVA: 0x0000ABFE File Offset: 0x00008DFE
		[HslMqttApi("ReadByteArray", "")]
		public virtual OperateResult<byte[]> Read(string address, ushort length)
		{
			return new OperateResult<byte[]>(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Byte[])" />
		// Token: 0x06001ACD RID: 6861 RVA: 0x0000AC0F File Offset: 0x00008E0F
		[HslMqttApi("WriteByteArray", "")]
		public virtual OperateResult Write(string address, byte[] value)
		{
			return new OperateResult(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBool(System.String,System.UInt16)" />
		// Token: 0x06001ACE RID: 6862 RVA: 0x0000AC20 File Offset: 0x00008E20
		[HslMqttApi("ReadBoolArray", "")]
		public virtual OperateResult<bool[]> ReadBool(string address, ushort length)
		{
			return new OperateResult<bool[]>(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBool(System.String)" />
		// Token: 0x06001ACF RID: 6863 RVA: 0x000860F0 File Offset: 0x000842F0
		[HslMqttApi("ReadBool", "")]
		public virtual OperateResult<bool> ReadBool(string address)
		{
			return ByteTransformHelper.GetResultFromArray<bool>(this.ReadBool(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Boolean[])" />
		// Token: 0x06001AD0 RID: 6864 RVA: 0x0000AC0F File Offset: 0x00008E0F
		[HslMqttApi("WriteBoolArray", "")]
		public virtual OperateResult Write(string address, bool[] value)
		{
			return new OperateResult(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Boolean)" />
		// Token: 0x06001AD1 RID: 6865 RVA: 0x000860FF File Offset: 0x000842FF
		[HslMqttApi("WriteBool", "")]
		public virtual OperateResult Write(string address, bool value)
		{
			return this.Write(address, new bool[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadCustomer``1(System.String)" />
		// Token: 0x06001AD2 RID: 6866 RVA: 0x00086114 File Offset: 0x00084314
		public OperateResult<T> ReadCustomer<T>(string address) where T : IDataTransfer, new()
		{
			OperateResult<T> operateResult = new OperateResult<T>();
			T content = Activator.CreateInstance<T>();
			OperateResult<byte[]> operateResult2 = this.Read(address, content.ReadCount);
			bool isSuccess = operateResult2.IsSuccess;
			if (isSuccess)
			{
				content.ParseSource(operateResult2.Content);
				operateResult.Content = content;
				operateResult.IsSuccess = true;
			}
			else
			{
				operateResult.ErrorCode = operateResult2.ErrorCode;
				operateResult.Message = operateResult2.Message;
			}
			return operateResult;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomer``1(System.String,``0)" />
		// Token: 0x06001AD3 RID: 6867 RVA: 0x00086198 File Offset: 0x00084398
		public OperateResult WriteCustomer<T>(string address, T data) where T : IDataTransfer, new()
		{
			return this.Write(address, data.ToSource());
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Read``1" />
		// Token: 0x06001AD4 RID: 6868 RVA: 0x000861AE File Offset: 0x000843AE
		public virtual OperateResult<T> Read<T>() where T : class, new()
		{
			return HslReflectionHelper.Read<T>(this);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write``1(``0)" />
		// Token: 0x06001AD5 RID: 6869 RVA: 0x000861B6 File Offset: 0x000843B6
		public virtual OperateResult Write<T>(T data) where T : class, new()
		{
			return HslReflectionHelper.Write<T>(data, this);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16(System.String)" />
		// Token: 0x06001AD6 RID: 6870 RVA: 0x000861BF File Offset: 0x000843BF
		[HslMqttApi("ReadInt16", "")]
		public OperateResult<short> ReadInt16(string address)
		{
			return ByteTransformHelper.GetResultFromArray<short>(this.ReadInt16(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16(System.String,System.UInt16)" />
		// Token: 0x06001AD7 RID: 6871 RVA: 0x000861D0 File Offset: 0x000843D0
		[HslMqttApi("ReadInt16Array", "")]
		public virtual OperateResult<short[]> ReadInt16(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<short[]>(this.Read(address, length * this.WordLength), (byte[] m) => this.ByteTransform.TransInt16(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16(System.String)" />
		// Token: 0x06001AD8 RID: 6872 RVA: 0x00086217 File Offset: 0x00084417
		[HslMqttApi("ReadUInt16", "")]
		public OperateResult<ushort> ReadUInt16(string address)
		{
			return ByteTransformHelper.GetResultFromArray<ushort>(this.ReadUInt16(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16(System.String,System.UInt16)" />
		// Token: 0x06001AD9 RID: 6873 RVA: 0x00086228 File Offset: 0x00084428
		[HslMqttApi("ReadUInt16Array", "")]
		public virtual OperateResult<ushort[]> ReadUInt16(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<ushort[]>(this.Read(address, length * this.WordLength), (byte[] m) => this.ByteTransform.TransUInt16(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32(System.String)" />
		// Token: 0x06001ADA RID: 6874 RVA: 0x0008626F File Offset: 0x0008446F
		[HslMqttApi("ReadInt32", "")]
		public OperateResult<int> ReadInt32(string address)
		{
			return ByteTransformHelper.GetResultFromArray<int>(this.ReadInt32(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32(System.String,System.UInt16)" />
		// Token: 0x06001ADB RID: 6875 RVA: 0x00086280 File Offset: 0x00084480
		[HslMqttApi("ReadInt32Array", "")]
		public virtual OperateResult<int[]> ReadInt32(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<int[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransInt32(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32(System.String)" />
		// Token: 0x06001ADC RID: 6876 RVA: 0x000862C9 File Offset: 0x000844C9
		[HslMqttApi("ReadUInt32", "")]
		public OperateResult<uint> ReadUInt32(string address)
		{
			return ByteTransformHelper.GetResultFromArray<uint>(this.ReadUInt32(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32(System.String,System.UInt16)" />
		// Token: 0x06001ADD RID: 6877 RVA: 0x000862D8 File Offset: 0x000844D8
		[HslMqttApi("ReadUInt32Array", "")]
		public virtual OperateResult<uint[]> ReadUInt32(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<uint[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransUInt32(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloat(System.String)" />
		// Token: 0x06001ADE RID: 6878 RVA: 0x00086321 File Offset: 0x00084521
		[HslMqttApi("ReadFloat", "")]
		public OperateResult<float> ReadFloat(string address)
		{
			return ByteTransformHelper.GetResultFromArray<float>(this.ReadFloat(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloat(System.String,System.UInt16)" />
		// Token: 0x06001ADF RID: 6879 RVA: 0x00086330 File Offset: 0x00084530
		[HslMqttApi("ReadFloatArray", "")]
		public virtual OperateResult<float[]> ReadFloat(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<float[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransSingle(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64(System.String)" />
		// Token: 0x06001AE0 RID: 6880 RVA: 0x00086379 File Offset: 0x00084579
		[HslMqttApi("ReadInt64", "")]
		public OperateResult<long> ReadInt64(string address)
		{
			return ByteTransformHelper.GetResultFromArray<long>(this.ReadInt64(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64(System.String,System.UInt16)" />
		// Token: 0x06001AE1 RID: 6881 RVA: 0x00086388 File Offset: 0x00084588
		[HslMqttApi("ReadInt64Array", "")]
		public virtual OperateResult<long[]> ReadInt64(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<long[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransInt64(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64(System.String)" />
		// Token: 0x06001AE2 RID: 6882 RVA: 0x000863D1 File Offset: 0x000845D1
		[HslMqttApi("ReadUInt64", "")]
		public OperateResult<ulong> ReadUInt64(string address)
		{
			return ByteTransformHelper.GetResultFromArray<ulong>(this.ReadUInt64(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64(System.String,System.UInt16)" />
		// Token: 0x06001AE3 RID: 6883 RVA: 0x000863E0 File Offset: 0x000845E0
		[HslMqttApi("ReadUInt64Array", "")]
		public virtual OperateResult<ulong[]> ReadUInt64(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<ulong[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransUInt64(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDouble(System.String)" />
		// Token: 0x06001AE4 RID: 6884 RVA: 0x00086429 File Offset: 0x00084629
		[HslMqttApi("ReadDouble", "")]
		public OperateResult<double> ReadDouble(string address)
		{
			return ByteTransformHelper.GetResultFromArray<double>(this.ReadDouble(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDouble(System.String,System.UInt16)" />
		// Token: 0x06001AE5 RID: 6885 RVA: 0x00086438 File Offset: 0x00084638
		[HslMqttApi("ReadDoubleArray", "")]
		public virtual OperateResult<double[]> ReadDouble(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<double[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransDouble(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadString(System.String,System.UInt16)" />
		// Token: 0x06001AE6 RID: 6886 RVA: 0x00086481 File Offset: 0x00084681
		[HslMqttApi("ReadString", "")]
		public virtual OperateResult<string> ReadString(string address, ushort length)
		{
			return this.ReadString(address, length, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadString(System.String,System.UInt16,System.Text.Encoding)" />
		// Token: 0x06001AE7 RID: 6887 RVA: 0x00086490 File Offset: 0x00084690
		public virtual OperateResult<string> ReadString(string address, ushort length, Encoding encoding)
		{
			return ByteTransformHelper.GetResultFromBytes<string>(this.Read(address, length), (byte[] m) => this.ByteTransform.TransString(m, 0, m.Length, encoding));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int16[])" />
		// Token: 0x06001AE8 RID: 6888 RVA: 0x000864CA File Offset: 0x000846CA
		[HslMqttApi("WriteInt16Array", "")]
		public virtual OperateResult Write(string address, short[] values)
		{
			return this.Write(address, base.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int16)" />
		// Token: 0x06001AE9 RID: 6889 RVA: 0x000864DF File Offset: 0x000846DF
		[HslMqttApi("WriteInt16", "")]
		public virtual OperateResult Write(string address, short value)
		{
			return this.Write(address, new short[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt16[])" />
		// Token: 0x06001AEA RID: 6890 RVA: 0x000864F2 File Offset: 0x000846F2
		[HslMqttApi("WriteUInt16Array", "")]
		public virtual OperateResult Write(string address, ushort[] values)
		{
			return this.Write(address, base.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt16)" />
		// Token: 0x06001AEB RID: 6891 RVA: 0x00086507 File Offset: 0x00084707
		[HslMqttApi("WriteUInt16", "")]
		public virtual OperateResult Write(string address, ushort value)
		{
			return this.Write(address, new ushort[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int32[])" />
		// Token: 0x06001AEC RID: 6892 RVA: 0x0008651A File Offset: 0x0008471A
		[HslMqttApi("WriteInt32Array", "")]
		public virtual OperateResult Write(string address, int[] values)
		{
			return this.Write(address, base.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int32)" />
		// Token: 0x06001AED RID: 6893 RVA: 0x0008652F File Offset: 0x0008472F
		[HslMqttApi("WriteInt32", "")]
		public OperateResult Write(string address, int value)
		{
			return this.Write(address, new int[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt32[])" />
		// Token: 0x06001AEE RID: 6894 RVA: 0x00086542 File Offset: 0x00084742
		[HslMqttApi("WriteUInt32Array", "")]
		public virtual OperateResult Write(string address, uint[] values)
		{
			return this.Write(address, base.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt32)" />
		// Token: 0x06001AEF RID: 6895 RVA: 0x00086557 File Offset: 0x00084757
		[HslMqttApi("WriteUInt32", "")]
		public OperateResult Write(string address, uint value)
		{
			return this.Write(address, new uint[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Single[])" />
		// Token: 0x06001AF0 RID: 6896 RVA: 0x0008656A File Offset: 0x0008476A
		[HslMqttApi("WriteFloatArray", "")]
		public virtual OperateResult Write(string address, float[] values)
		{
			return this.Write(address, base.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Single)" />
		// Token: 0x06001AF1 RID: 6897 RVA: 0x0008657F File Offset: 0x0008477F
		[HslMqttApi("WriteFloat", "")]
		public OperateResult Write(string address, float value)
		{
			return this.Write(address, new float[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int64[])" />
		// Token: 0x06001AF2 RID: 6898 RVA: 0x00086592 File Offset: 0x00084792
		[HslMqttApi("WriteInt64Array", "")]
		public virtual OperateResult Write(string address, long[] values)
		{
			return this.Write(address, base.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int64)" />
		// Token: 0x06001AF3 RID: 6899 RVA: 0x000865A7 File Offset: 0x000847A7
		[HslMqttApi("WriteInt64", "")]
		public OperateResult Write(string address, long value)
		{
			return this.Write(address, new long[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt64[])" />
		// Token: 0x06001AF4 RID: 6900 RVA: 0x000865BA File Offset: 0x000847BA
		[HslMqttApi("WriteUInt64Array", "")]
		public virtual OperateResult Write(string address, ulong[] values)
		{
			return this.Write(address, base.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt64)" />
		// Token: 0x06001AF5 RID: 6901 RVA: 0x000865CF File Offset: 0x000847CF
		[HslMqttApi("WriteUInt64", "")]
		public OperateResult Write(string address, ulong value)
		{
			return this.Write(address, new ulong[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Double[])" />
		// Token: 0x06001AF6 RID: 6902 RVA: 0x000865E2 File Offset: 0x000847E2
		[HslMqttApi("WriteDoubleArray", "")]
		public virtual OperateResult Write(string address, double[] values)
		{
			return this.Write(address, base.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Double)" />
		// Token: 0x06001AF7 RID: 6903 RVA: 0x000865F7 File Offset: 0x000847F7
		[HslMqttApi("WriteDouble", "")]
		public OperateResult Write(string address, double value)
		{
			return this.Write(address, new double[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String)" />
		// Token: 0x06001AF8 RID: 6904 RVA: 0x0008660A File Offset: 0x0008480A
		[HslMqttApi("WriteString", "")]
		public virtual OperateResult Write(string address, string value)
		{
			return this.Write(address, value, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Int32)" />
		// Token: 0x06001AF9 RID: 6905 RVA: 0x00086619 File Offset: 0x00084819
		public virtual OperateResult Write(string address, string value, int length)
		{
			return this.Write(address, value, length, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Text.Encoding)" />
		// Token: 0x06001AFA RID: 6906 RVA: 0x0008662C File Offset: 0x0008482C
		public virtual OperateResult Write(string address, string value, Encoding encoding)
		{
			byte[] array = base.ByteTransform.TransByte(value, encoding);
			bool flag = this.WordLength == 1;
			if (flag)
			{
				array = SoftBasic.ArrayExpandToLengthEven<byte>(array);
			}
			return this.Write(address, array);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x06001AFB RID: 6907 RVA: 0x00086668 File Offset: 0x00084868
		public virtual OperateResult Write(string address, string value, int length, Encoding encoding)
		{
			byte[] array = base.ByteTransform.TransByte(value, encoding);
			bool flag = this.WordLength == 1;
			if (flag)
			{
				array = SoftBasic.ArrayExpandToLengthEven<byte>(array);
			}
			array = SoftBasic.ArrayExpandToLength<byte>(array, length);
			return this.Write(address, array);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Boolean,System.Int32,System.Int32)" />
		// Token: 0x06001AFC RID: 6908 RVA: 0x0000B1ED File Offset: 0x000093ED
		[HslMqttApi("WaitBool", "")]
		public OperateResult<TimeSpan> Wait(string address, bool waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int16,System.Int32,System.Int32)" />
		// Token: 0x06001AFD RID: 6909 RVA: 0x0000B1FA File Offset: 0x000093FA
		[HslMqttApi("WaitInt16", "")]
		public OperateResult<TimeSpan> Wait(string address, short waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt16,System.Int32,System.Int32)" />
		// Token: 0x06001AFE RID: 6910 RVA: 0x0000B207 File Offset: 0x00009407
		[HslMqttApi("WaitUInt16", "")]
		public OperateResult<TimeSpan> Wait(string address, ushort waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int32,System.Int32,System.Int32)" />
		// Token: 0x06001AFF RID: 6911 RVA: 0x0000B214 File Offset: 0x00009414
		[HslMqttApi("WaitInt32", "")]
		public OperateResult<TimeSpan> Wait(string address, int waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt32,System.Int32,System.Int32)" />
		// Token: 0x06001B00 RID: 6912 RVA: 0x0000B221 File Offset: 0x00009421
		[HslMqttApi("WaitUInt32", "")]
		public OperateResult<TimeSpan> Wait(string address, uint waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int64,System.Int32,System.Int32)" />
		// Token: 0x06001B01 RID: 6913 RVA: 0x0000B22E File Offset: 0x0000942E
		[HslMqttApi("WaitInt64", "")]
		public OperateResult<TimeSpan> Wait(string address, long waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt64,System.Int32,System.Int32)" />
		// Token: 0x06001B02 RID: 6914 RVA: 0x0000B23B File Offset: 0x0000943B
		[HslMqttApi("WaitUInt64", "")]
		public OperateResult<TimeSpan> Wait(string address, ulong waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Boolean,System.Int32,System.Int32)" />
		// Token: 0x06001B03 RID: 6915 RVA: 0x000866B0 File Offset: 0x000848B0
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, bool waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDeviceBase.<WaitAsync>d__60 <WaitAsync>d__ = new NetworkDeviceBase.<WaitAsync>d__60();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WaitAsync>d__60>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int16,System.Int32,System.Int32)" />
		// Token: 0x06001B04 RID: 6916 RVA: 0x00086714 File Offset: 0x00084914
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, short waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDeviceBase.<WaitAsync>d__61 <WaitAsync>d__ = new NetworkDeviceBase.<WaitAsync>d__61();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WaitAsync>d__61>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt16,System.Int32,System.Int32)" />
		// Token: 0x06001B05 RID: 6917 RVA: 0x00086778 File Offset: 0x00084978
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, ushort waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDeviceBase.<WaitAsync>d__62 <WaitAsync>d__ = new NetworkDeviceBase.<WaitAsync>d__62();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WaitAsync>d__62>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int32,System.Int32,System.Int32)" />
		// Token: 0x06001B06 RID: 6918 RVA: 0x000867DC File Offset: 0x000849DC
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, int waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDeviceBase.<WaitAsync>d__63 <WaitAsync>d__ = new NetworkDeviceBase.<WaitAsync>d__63();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WaitAsync>d__63>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt32,System.Int32,System.Int32)" />
		// Token: 0x06001B07 RID: 6919 RVA: 0x00086840 File Offset: 0x00084A40
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, uint waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDeviceBase.<WaitAsync>d__64 <WaitAsync>d__ = new NetworkDeviceBase.<WaitAsync>d__64();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WaitAsync>d__64>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int64,System.Int32,System.Int32)" />
		// Token: 0x06001B08 RID: 6920 RVA: 0x000868A4 File Offset: 0x00084AA4
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, long waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDeviceBase.<WaitAsync>d__65 <WaitAsync>d__ = new NetworkDeviceBase.<WaitAsync>d__65();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WaitAsync>d__65>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt64,System.Int32,System.Int32)" />
		// Token: 0x06001B09 RID: 6921 RVA: 0x00086908 File Offset: 0x00084B08
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, ulong waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDeviceBase.<WaitAsync>d__66 <WaitAsync>d__ = new NetworkDeviceBase.<WaitAsync>d__66();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WaitAsync>d__66>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadAsync(System.String,System.UInt16)" />
		// Token: 0x06001B0A RID: 6922 RVA: 0x0008696C File Offset: 0x00084B6C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<byte[]>> ReadAsync(string address, ushort length)
		{
			NetworkDeviceBase.<ReadAsync>d__67 <ReadAsync>d__ = new NetworkDeviceBase.<ReadAsync>d__67();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<byte[]>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.address = address;
			<ReadAsync>d__.length = length;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadAsync>d__67>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Byte[])" />
		// Token: 0x06001B0B RID: 6923 RVA: 0x000869C0 File Offset: 0x00084BC0
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, byte[] value)
		{
			NetworkDeviceBase.<WriteAsync>d__68 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__68();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__68>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBoolAsync(System.String,System.UInt16)" />
		// Token: 0x06001B0C RID: 6924 RVA: 0x00086A14 File Offset: 0x00084C14
		[DebuggerStepThrough]
		public virtual Task<OperateResult<bool[]>> ReadBoolAsync(string address, ushort length)
		{
			NetworkDeviceBase.<ReadBoolAsync>d__69 <ReadBoolAsync>d__ = new NetworkDeviceBase.<ReadBoolAsync>d__69();
			<ReadBoolAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<bool[]>>.Create();
			<ReadBoolAsync>d__.<>4__this = this;
			<ReadBoolAsync>d__.address = address;
			<ReadBoolAsync>d__.length = length;
			<ReadBoolAsync>d__.<>1__state = -1;
			<ReadBoolAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadBoolAsync>d__69>(ref <ReadBoolAsync>d__);
			return <ReadBoolAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBoolAsync(System.String)" />
		// Token: 0x06001B0D RID: 6925 RVA: 0x00086A68 File Offset: 0x00084C68
		[DebuggerStepThrough]
		public virtual Task<OperateResult<bool>> ReadBoolAsync(string address)
		{
			NetworkDeviceBase.<ReadBoolAsync>d__70 <ReadBoolAsync>d__ = new NetworkDeviceBase.<ReadBoolAsync>d__70();
			<ReadBoolAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<bool>>.Create();
			<ReadBoolAsync>d__.<>4__this = this;
			<ReadBoolAsync>d__.address = address;
			<ReadBoolAsync>d__.<>1__state = -1;
			<ReadBoolAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadBoolAsync>d__70>(ref <ReadBoolAsync>d__);
			return <ReadBoolAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Boolean[])" />
		// Token: 0x06001B0E RID: 6926 RVA: 0x00086AB4 File Offset: 0x00084CB4
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, bool[] value)
		{
			NetworkDeviceBase.<WriteAsync>d__71 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__71();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__71>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Boolean)" />
		// Token: 0x06001B0F RID: 6927 RVA: 0x00086B08 File Offset: 0x00084D08
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, bool value)
		{
			NetworkDeviceBase.<WriteAsync>d__72 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__72();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__72>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomerAsync``1(System.String,``0)" />
		// Token: 0x06001B10 RID: 6928 RVA: 0x00086B5C File Offset: 0x00084D5C
		[DebuggerStepThrough]
		public Task<OperateResult<T>> ReadCustomerAsync<T>(string address) where T : IDataTransfer, new()
		{
			NetworkDeviceBase.<ReadCustomerAsync>d__73<T> <ReadCustomerAsync>d__ = new NetworkDeviceBase.<ReadCustomerAsync>d__73<T>();
			<ReadCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadCustomerAsync>d__.<>4__this = this;
			<ReadCustomerAsync>d__.address = address;
			<ReadCustomerAsync>d__.<>1__state = -1;
			<ReadCustomerAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadCustomerAsync>d__73<T>>(ref <ReadCustomerAsync>d__);
			return <ReadCustomerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomerAsync``1(System.String,``0)" />
		// Token: 0x06001B11 RID: 6929 RVA: 0x00086BA8 File Offset: 0x00084DA8
		[DebuggerStepThrough]
		public Task<OperateResult> WriteCustomerAsync<T>(string address, T data) where T : IDataTransfer, new()
		{
			NetworkDeviceBase.<WriteCustomerAsync>d__74<T> <WriteCustomerAsync>d__ = new NetworkDeviceBase.<WriteCustomerAsync>d__74<T>();
			<WriteCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteCustomerAsync>d__.<>4__this = this;
			<WriteCustomerAsync>d__.address = address;
			<WriteCustomerAsync>d__.data = data;
			<WriteCustomerAsync>d__.<>1__state = -1;
			<WriteCustomerAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteCustomerAsync>d__74<T>>(ref <WriteCustomerAsync>d__);
			return <WriteCustomerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadAsync``1" />
		// Token: 0x06001B12 RID: 6930 RVA: 0x00086BFC File Offset: 0x00084DFC
		[DebuggerStepThrough]
		public virtual Task<OperateResult<T>> ReadAsync<T>() where T : class, new()
		{
			NetworkDeviceBase.<ReadAsync>d__75<T> <ReadAsync>d__ = new NetworkDeviceBase.<ReadAsync>d__75<T>();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadAsync>d__75<T>>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync``1(``0)" />
		// Token: 0x06001B13 RID: 6931 RVA: 0x00086C40 File Offset: 0x00084E40
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync<T>(T data) where T : class, new()
		{
			NetworkDeviceBase.<WriteAsync>d__76<T> <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__76<T>();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.data = data;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__76<T>>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16Async(System.String)" />
		// Token: 0x06001B14 RID: 6932 RVA: 0x00086C8C File Offset: 0x00084E8C
		[DebuggerStepThrough]
		public Task<OperateResult<short>> ReadInt16Async(string address)
		{
			NetworkDeviceBase.<ReadInt16Async>d__77 <ReadInt16Async>d__ = new NetworkDeviceBase.<ReadInt16Async>d__77();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadInt16Async>d__77>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16Async(System.String,System.UInt16)" />
		// Token: 0x06001B15 RID: 6933 RVA: 0x00086CD8 File Offset: 0x00084ED8
		[DebuggerStepThrough]
		public virtual Task<OperateResult<short[]>> ReadInt16Async(string address, ushort length)
		{
			NetworkDeviceBase.<ReadInt16Async>d__78 <ReadInt16Async>d__ = new NetworkDeviceBase.<ReadInt16Async>d__78();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short[]>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.length = length;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadInt16Async>d__78>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16Async(System.String)" />
		// Token: 0x06001B16 RID: 6934 RVA: 0x00086D2C File Offset: 0x00084F2C
		[DebuggerStepThrough]
		public Task<OperateResult<ushort>> ReadUInt16Async(string address)
		{
			NetworkDeviceBase.<ReadUInt16Async>d__79 <ReadUInt16Async>d__ = new NetworkDeviceBase.<ReadUInt16Async>d__79();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadUInt16Async>d__79>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16Async(System.String,System.UInt16)" />
		// Token: 0x06001B17 RID: 6935 RVA: 0x00086D78 File Offset: 0x00084F78
		[DebuggerStepThrough]
		public virtual Task<OperateResult<ushort[]>> ReadUInt16Async(string address, ushort length)
		{
			NetworkDeviceBase.<ReadUInt16Async>d__80 <ReadUInt16Async>d__ = new NetworkDeviceBase.<ReadUInt16Async>d__80();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort[]>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.length = length;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadUInt16Async>d__80>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32Async(System.String)" />
		// Token: 0x06001B18 RID: 6936 RVA: 0x00086DCC File Offset: 0x00084FCC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadInt32Async(string address)
		{
			NetworkDeviceBase.<ReadInt32Async>d__81 <ReadInt32Async>d__ = new NetworkDeviceBase.<ReadInt32Async>d__81();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadInt32Async>d__81>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32Async(System.String,System.UInt16)" />
		// Token: 0x06001B19 RID: 6937 RVA: 0x00086E18 File Offset: 0x00085018
		[DebuggerStepThrough]
		public virtual Task<OperateResult<int[]>> ReadInt32Async(string address, ushort length)
		{
			NetworkDeviceBase.<ReadInt32Async>d__82 <ReadInt32Async>d__ = new NetworkDeviceBase.<ReadInt32Async>d__82();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int[]>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.length = length;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadInt32Async>d__82>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32Async(System.String)" />
		// Token: 0x06001B1A RID: 6938 RVA: 0x00086E6C File Offset: 0x0008506C
		[DebuggerStepThrough]
		public Task<OperateResult<uint>> ReadUInt32Async(string address)
		{
			NetworkDeviceBase.<ReadUInt32Async>d__83 <ReadUInt32Async>d__ = new NetworkDeviceBase.<ReadUInt32Async>d__83();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadUInt32Async>d__83>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32Async(System.String,System.UInt16)" />
		// Token: 0x06001B1B RID: 6939 RVA: 0x00086EB8 File Offset: 0x000850B8
		[DebuggerStepThrough]
		public virtual Task<OperateResult<uint[]>> ReadUInt32Async(string address, ushort length)
		{
			NetworkDeviceBase.<ReadUInt32Async>d__84 <ReadUInt32Async>d__ = new NetworkDeviceBase.<ReadUInt32Async>d__84();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint[]>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.length = length;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadUInt32Async>d__84>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloatAsync(System.String)" />
		// Token: 0x06001B1C RID: 6940 RVA: 0x00086F0C File Offset: 0x0008510C
		[DebuggerStepThrough]
		public Task<OperateResult<float>> ReadFloatAsync(string address)
		{
			NetworkDeviceBase.<ReadFloatAsync>d__85 <ReadFloatAsync>d__ = new NetworkDeviceBase.<ReadFloatAsync>d__85();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadFloatAsync>d__85>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloatAsync(System.String,System.UInt16)" />
		// Token: 0x06001B1D RID: 6941 RVA: 0x00086F58 File Offset: 0x00085158
		[DebuggerStepThrough]
		public virtual Task<OperateResult<float[]>> ReadFloatAsync(string address, ushort length)
		{
			NetworkDeviceBase.<ReadFloatAsync>d__86 <ReadFloatAsync>d__ = new NetworkDeviceBase.<ReadFloatAsync>d__86();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float[]>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.length = length;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadFloatAsync>d__86>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64Async(System.String)" />
		// Token: 0x06001B1E RID: 6942 RVA: 0x00086FAC File Offset: 0x000851AC
		[DebuggerStepThrough]
		public Task<OperateResult<long>> ReadInt64Async(string address)
		{
			NetworkDeviceBase.<ReadInt64Async>d__87 <ReadInt64Async>d__ = new NetworkDeviceBase.<ReadInt64Async>d__87();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadInt64Async>d__87>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64Async(System.String,System.UInt16)" />
		// Token: 0x06001B1F RID: 6943 RVA: 0x00086FF8 File Offset: 0x000851F8
		[DebuggerStepThrough]
		public virtual Task<OperateResult<long[]>> ReadInt64Async(string address, ushort length)
		{
			NetworkDeviceBase.<ReadInt64Async>d__88 <ReadInt64Async>d__ = new NetworkDeviceBase.<ReadInt64Async>d__88();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long[]>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.length = length;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadInt64Async>d__88>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64Async(System.String)" />
		// Token: 0x06001B20 RID: 6944 RVA: 0x0008704C File Offset: 0x0008524C
		[DebuggerStepThrough]
		public Task<OperateResult<ulong>> ReadUInt64Async(string address)
		{
			NetworkDeviceBase.<ReadUInt64Async>d__89 <ReadUInt64Async>d__ = new NetworkDeviceBase.<ReadUInt64Async>d__89();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadUInt64Async>d__89>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64Async(System.String,System.UInt16)" />
		// Token: 0x06001B21 RID: 6945 RVA: 0x00087098 File Offset: 0x00085298
		[DebuggerStepThrough]
		public virtual Task<OperateResult<ulong[]>> ReadUInt64Async(string address, ushort length)
		{
			NetworkDeviceBase.<ReadUInt64Async>d__90 <ReadUInt64Async>d__ = new NetworkDeviceBase.<ReadUInt64Async>d__90();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong[]>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.length = length;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<NetworkDeviceBase.<ReadUInt64Async>d__90>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDoubleAsync(System.String)" />
		// Token: 0x06001B22 RID: 6946 RVA: 0x000870EC File Offset: 0x000852EC
		[DebuggerStepThrough]
		public Task<OperateResult<double>> ReadDoubleAsync(string address)
		{
			NetworkDeviceBase.<ReadDoubleAsync>d__91 <ReadDoubleAsync>d__ = new NetworkDeviceBase.<ReadDoubleAsync>d__91();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadDoubleAsync>d__91>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDoubleAsync(System.String,System.UInt16)" />
		// Token: 0x06001B23 RID: 6947 RVA: 0x00087138 File Offset: 0x00085338
		[DebuggerStepThrough]
		public virtual Task<OperateResult<double[]>> ReadDoubleAsync(string address, ushort length)
		{
			NetworkDeviceBase.<ReadDoubleAsync>d__92 <ReadDoubleAsync>d__ = new NetworkDeviceBase.<ReadDoubleAsync>d__92();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double[]>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.length = length;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadDoubleAsync>d__92>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadStringAsync(System.String,System.UInt16)" />
		// Token: 0x06001B24 RID: 6948 RVA: 0x0008718C File Offset: 0x0008538C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<string>> ReadStringAsync(string address, ushort length)
		{
			NetworkDeviceBase.<ReadStringAsync>d__93 <ReadStringAsync>d__ = new NetworkDeviceBase.<ReadStringAsync>d__93();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadStringAsync>d__93>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadStringAsync(System.String,System.UInt16,System.Text.Encoding)" />
		// Token: 0x06001B25 RID: 6949 RVA: 0x000871E0 File Offset: 0x000853E0
		[DebuggerStepThrough]
		public virtual Task<OperateResult<string>> ReadStringAsync(string address, ushort length, Encoding encoding)
		{
			NetworkDeviceBase.<ReadStringAsync>d__94 <ReadStringAsync>d__ = new NetworkDeviceBase.<ReadStringAsync>d__94();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.encoding = encoding;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<NetworkDeviceBase.<ReadStringAsync>d__94>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int16[])" />
		// Token: 0x06001B26 RID: 6950 RVA: 0x0008723C File Offset: 0x0008543C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, short[] values)
		{
			NetworkDeviceBase.<WriteAsync>d__95 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__95();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__95>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int16)" />
		// Token: 0x06001B27 RID: 6951 RVA: 0x00087290 File Offset: 0x00085490
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, short value)
		{
			NetworkDeviceBase.<WriteAsync>d__96 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__96();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__96>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt16[])" />
		// Token: 0x06001B28 RID: 6952 RVA: 0x000872E4 File Offset: 0x000854E4
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ushort[] values)
		{
			NetworkDeviceBase.<WriteAsync>d__97 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__97();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__97>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt16)" />
		// Token: 0x06001B29 RID: 6953 RVA: 0x00087338 File Offset: 0x00085538
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ushort value)
		{
			NetworkDeviceBase.<WriteAsync>d__98 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__98();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__98>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int32[])" />
		// Token: 0x06001B2A RID: 6954 RVA: 0x0008738C File Offset: 0x0008558C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, int[] values)
		{
			NetworkDeviceBase.<WriteAsync>d__99 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__99();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__99>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int32)" />
		// Token: 0x06001B2B RID: 6955 RVA: 0x000873E0 File Offset: 0x000855E0
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, int value)
		{
			NetworkDeviceBase.<WriteAsync>d__100 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__100();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__100>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt32[])" />
		// Token: 0x06001B2C RID: 6956 RVA: 0x00087434 File Offset: 0x00085634
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, uint[] values)
		{
			NetworkDeviceBase.<WriteAsync>d__101 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__101();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__101>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt32)" />
		// Token: 0x06001B2D RID: 6957 RVA: 0x00087488 File Offset: 0x00085688
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, uint value)
		{
			NetworkDeviceBase.<WriteAsync>d__102 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__102();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__102>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Single[])" />
		// Token: 0x06001B2E RID: 6958 RVA: 0x000874DC File Offset: 0x000856DC
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, float[] values)
		{
			NetworkDeviceBase.<WriteAsync>d__103 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__103();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__103>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Single)" />
		// Token: 0x06001B2F RID: 6959 RVA: 0x00087530 File Offset: 0x00085730
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, float value)
		{
			NetworkDeviceBase.<WriteAsync>d__104 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__104();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__104>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int64[])" />
		// Token: 0x06001B30 RID: 6960 RVA: 0x00087584 File Offset: 0x00085784
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, long[] values)
		{
			NetworkDeviceBase.<WriteAsync>d__105 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__105();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__105>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int64)" />
		// Token: 0x06001B31 RID: 6961 RVA: 0x000875D8 File Offset: 0x000857D8
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, long value)
		{
			NetworkDeviceBase.<WriteAsync>d__106 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__106();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__106>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt64[])" />
		// Token: 0x06001B32 RID: 6962 RVA: 0x0008762C File Offset: 0x0008582C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ulong[] values)
		{
			NetworkDeviceBase.<WriteAsync>d__107 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__107();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__107>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt64)" />
		// Token: 0x06001B33 RID: 6963 RVA: 0x00087680 File Offset: 0x00085880
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, ulong value)
		{
			NetworkDeviceBase.<WriteAsync>d__108 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__108();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__108>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Double[])" />
		// Token: 0x06001B34 RID: 6964 RVA: 0x000876D4 File Offset: 0x000858D4
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, double[] values)
		{
			NetworkDeviceBase.<WriteAsync>d__109 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__109();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__109>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Double)" />
		// Token: 0x06001B35 RID: 6965 RVA: 0x00087728 File Offset: 0x00085928
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, double value)
		{
			NetworkDeviceBase.<WriteAsync>d__110 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__110();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__110>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String)" />
		// Token: 0x06001B36 RID: 6966 RVA: 0x0008777C File Offset: 0x0008597C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value)
		{
			NetworkDeviceBase.<WriteAsync>d__111 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__111();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__111>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Text.Encoding)" />
		// Token: 0x06001B37 RID: 6967 RVA: 0x000877D0 File Offset: 0x000859D0
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, Encoding encoding)
		{
			NetworkDeviceBase.<WriteAsync>d__112 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__112();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.encoding = encoding;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__112>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Int32)" />
		// Token: 0x06001B38 RID: 6968 RVA: 0x0008782C File Offset: 0x00085A2C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, int length)
		{
			NetworkDeviceBase.<WriteAsync>d__113 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__113();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.length = length;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__113>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x06001B39 RID: 6969 RVA: 0x00087888 File Offset: 0x00085A88
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, int length, Encoding encoding)
		{
			NetworkDeviceBase.<WriteAsync>d__114 <WriteAsync>d__ = new NetworkDeviceBase.<WriteAsync>d__114();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.length = length;
			<WriteAsync>d__.encoding = encoding;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDeviceBase.<WriteAsync>d__114>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}
	}
}
